#include <iostream>
using namespace std;

class Single{
    private:
        int value;
        // 构造函数私有化
        Single(int v):value(v){}
        #if 0
            // C++ 11 前的版本 不想用某个特殊的成员函数 就把函数体置NULL即可
            // 拷贝构造函数私有化
            Single(const Single &other){}
        #else
            // C++ 11 后的版本支持  = delete 的写法  表示编译时删除该函数
            Single(const Single &other) = delete;
        #endif
        // 提供一个静态成员指针，永远指向唯一的实例化的对象；
        static Single *p;
    public:
        // 提供一个静态成员函数，每次调用该函数，都返回唯一的指针；
        static Single *get_instance(void){
            if(nullptr == p){
                p = new Single(0);
            }
            return p;
        }
        void set_value(int x){
            value = x;
        }
        int get_value(){
            return value;
        }
        // 销毁唯一的实例
        static void destroy_instance(void){
            if(nullptr != p){
                delete p;
                p = nullptr;
            }
        }
};

// 静态成员指针变量 类外全局处初始化 
Single *Single::p = nullptr;

int main(int argc, const char *argv[]){
    // 由于构造函数私有化了 不能在类外直接实例对象了
    // Single s(10); // 报错

    // 通过静态成员函数 来 得到唯一的实例
    Single *my_single1 = Single::get_instance();
    my_single1->set_value(100);
    cout << my_single1->get_value() << endl; // 100

    // 不管定义多少个指针 只要通过 get_instance 方法获取实例 获取到的都是同一个实例
    Single *my_single2 = Single::get_instance();
    cout << my_single2->get_value() << endl; // 100
    Single *my_single3 = Single::get_instance();
    cout << my_single3->get_value() << endl; // 100

    cout << my_single1 << " " << my_single2 << " " << my_single3 << endl; // 一样的

    // 销毁实例
    Single::destroy_instance();
    // 即使调用多次 也不会 double free  因为我们内部做了判断
    Single::destroy_instance();
    Single::destroy_instance();

    return 0;
}